#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>
using namespace std;
////template<T>
//
//void fun(int& x)
//{
//	cout << "左值引用" << endl;
//
//}
//void fun(const int &x)
//{
//	cout << "const 左值引用" << endl;
//
//}
//void fun(int&& x)
//{
//	cout << "右值引用" << endl;
//}
//void fun(const int&& x)
//{
//	cout << "const 右值引用" << endl;
//}
//template<typename T>
//void preferfoward(T&& t)
//{
//	fun(t);
//
//}
//int main()
//{
//	preferfoward(10);
//
//	int a = 1;
//	preferfoward(a);
//	preferfoward(move(a));
//
//
//	const int b = 1;
//	preferfoward(b);
//	preferfoward(move(b));
//
//
//	return 0;
//}


//template<typename T>
//
//void fun(int& x)
//{
//	cout << "左值引用" << endl;
//
//}
//void fun(const int& x)
//{
//	cout << "const 左值引用" << endl;
//
//}
//void fun(int&& x)
//{
//	cout << "右值引用" << endl;
//}
//void fun(const int&& x)
//{
//	cout << "const 右值引用" << endl;
//}
//template<typename T>
//void preferfoward(T&& t)
//{
//	fun(forward<T>(t));
//
//}
//int main()
//{
//	preferfoward(10);
//	cout << ">>>>>>>>>>>>>>>>>>>>>>>" << endl;
//	int a=1;
//	preferfoward(a);
//	preferfoward(move(a));
//
//	cout << ">>>>>>>>>>>>>>>>>>>>>>>" << endl;
//	const int b=0 ;
//	preferfoward(b);
//	preferfoward(move(b));
//	cout << ">>>>>>>>>>>>>>>>>>>>>>>" << endl;
//
//	return 0;
//}
//namespace cmj
//{
//	string;
//}
//namespace cmj
//{
//	class string
//	{
//	public:
//		typedef char* iterator;
//		iterator begin()
//		{
//			return _str;
//		}
//		iterator end()
//		{
//			return _str + _size;
//		}
//		string(const char* str = "")
//			:_size(strlen(str))
//			, _capacity(_size)
//		{
//			//cout << "string(char* str)" << endl;
//			_str = new char[_capacity + 1];
//			strcpy(_str, str);
//		}
//		// s1.swap(s2)
//		void swap(string& s)
//		{
//			::swap(_str, s._str);
//			::swap(_size, s._size);
//			::swap(_capacity, s._capacity);
//		}
//		// 拷贝构造
//		string(const string& s)
//			:_str(nullptr)
//		{
//			cout << "string(const string& s) -- 深拷贝" << endl;
//			string tmp(s._str);
//			swap(tmp);
//		}
//		// 赋值重载
//		string& operator=(const string& s)
//		{
//				cout << "string& operator=(string s) -- 深拷贝" << endl;
//			string tmp(s);
//			swap(tmp);
//			return *this;
//		}
//		// 移动构造
//		string(string&& s)
//			:_str(nullptr)
//			, _size(0)
//			, _capacity(0)
//		{
//			cout << "string(string&& s) -- 移动语义" << endl;
//			swap(s);
//		}
//		// 移动赋值
//		string& operator=(string&& s)
//		{
//			cout << "string& operator=(string&& s) -- 移动语义" << endl;
//			swap(s);
//			return *this;
//		}
//		~string()
//		{
//			delete[] _str;
//			_str = nullptr;
//		}
//		char& operator[](size_t pos)
//		{
//			assert(pos < _size);
//			return _str[pos];
//		}
//		void reserve(size_t n)
//		{
//			if (n > _capacity)
//			{
//				char* tmp = new char[n + 1];
//				strcpy(tmp, _str);
//				delete[] _str;
//				_str = tmp;
//				_capacity = n;
//			}
//		}
//		void push_back(char ch)
//		{
//			if (_size >= _capacity)
//			{
//				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
//				reserve(newcapacity);
//			}
//	
//				_str[_size] = ch;
//			++_size;
//			_str[_size] = '\0';
//		}
//		//string operator+=(char ch)
//		string& operator+=(char ch)
//		{
//			push_back(ch);
//			return *this;
//		}
//		const char* c_str() const
//		{
//			return _str;
//		}
//	private:
//		char* _str;
//		size_t _size;
//		size_t _capacity; // 不包含最后做标识的\0
//	};
//}
//template<class T>
//
//struct linode {
//	linode* next = nullptr;
//	linode* prev = nullptr;
//	T data;
//};
//template<class T>
//class list
//{
//	typedef linode<T> node;
//public :
//	list()
//	{
//		head = new node;
//		head->next = head;
//		head->prev = head;
//	}
//	void insert(node* pos, T&& x)
//	{
//		node* prev = pos->prev;
//		node* newnode = new node;
//		newnode->data = forward<T>(x);
//		prev->next = newnode;
//		newnode->prev = prev;
//		newnode->next = pos;
//		pos->prev = newnode;
//	}
//	
//	void pushfront(T && x)
//	{
//		insert(head->next, forward<T>(x));
//	}
//	void pushback(T && x)
//	{
//		insert(head, forward<T>(x));
//	}
//	void print()
//	{
//		node* hhh = head;
//		head = head->next;
//		while (head != hhh)
//		{
//			cout << head->data;
//			head = head->next
//		}
//	}
//private:
//	node* head;
//};
//int main()
//{
//
//	list<cmj::string> lt;
//	lt.pushback("0000");
//	lt.pushfront("11111");
//	lt.print();
//	return 0;
//	
//
//}

#include <iostream>
#include <cstring>
#include <cassert>
#include <utility>

namespace cmj
{
    class string
    {
    public:
        typedef char* iterator;
        iterator begin()
        {
            return _str;
        }
        iterator end()
        {
            return _str + _size;
        }
        string(const char* str = "")
            :_size(strlen(str))
            , _capacity(_size)
        {
            //std::cout << "string(char* str)" << std::endl;
            _str = new char[_capacity + 1];
            strcpy(_str, str);
        }
        // s1.swap(s2)
        void swap(string& s)
        {
            std::swap(_str, s._str);
            std::swap(_size, s._size);
            std::swap(_capacity, s._capacity);
        }
        // 拷贝构造
        string(const string& s)
            :_str(nullptr)
        {
            std::cout << "string(const string& s) -- 深拷贝" << std::endl;
            string tmp(s._str);
            swap(tmp);
        }
        // 赋值重载
        string& operator=(const string& s)
        {
            std::cout << "string& operator=(string s) -- 深拷贝" << std::endl;
            string tmp(s);
            swap(tmp);
            return *this;
        }
        // 移动构造
        string(string&& s)
            :_str(nullptr)
            , _size(0)
            , _capacity(0)
        {
            std::cout << "string(string&& s) -- 移动语义" << std::endl;
            swap(s);
        }
        // 移动赋值
        string& operator=(string&& s)
        {
            std::cout << "string& operator=(string&& s) -- 移动语义" << std::endl;
            swap(s);
            return *this;
        }
        ~string()
        {
            delete[] _str;
            _str = nullptr;
        }
        char& operator[](size_t pos)
        {
            assert(pos < _size);
            return _str[pos];
        }
        void reserve(size_t n)
        {
            if (n > _capacity)
            {
                char* tmp = new char[n + 1];
                strcpy(tmp, _str);
                delete[] _str;
                _str = tmp;
                _capacity = n;
            }
        }
        void push_back(char ch)
        {
            if (_size >= _capacity)
            {
                size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
                reserve(newcapacity);
            }

            _str[_size] = ch;
            ++_size;
            _str[_size] = '\0';
        }
        //string operator+=(char ch)
        string& operator+=(char ch)
        {
            push_back(ch);
            return *this;
        }
        const char* c_str() const
        {
            return _str;
        }
    private:
        char* _str;
        size_t _size;
        size_t _capacity; // 不包含最后做标识的\0
    };
}

template<class T>
struct linode {
    linode* next = nullptr;
    linode* prev = nullptr;
    T data;
};

template<class T>
class list
{
    typedef linode<T> node;
public:
    list()
    {
        head = new node;
        head->next = head;
        head->prev = head;
    }

    void insert(node* pos, T&& x)
    {
        node* prev = pos->prev;
        node* newnode = new node;
        newnode->data = std::forward<T>(x);
        prev->next = newnode;
        newnode->prev = prev;
        newnode->next = pos;
        pos->prev = newnode;
    }

    void insert(node* pos, const T& x)
    {
        node* prev = pos->prev;
        node* newnode = new node;
        newnode->data = x;
        prev->next = newnode;
        newnode->prev = prev;
        newnode->next = pos;
        pos->prev = newnode;
    }

    void pushfront(T&& x)
    {
        insert(head->next, std::forward<T>(x));
    }

    void pushfront(const T& x)
    {
        insert(head->next, x);
    }

    void pushback(T&& x)
    {
        insert(head, std::forward<T>(x));
    }

    void pushback(const T& x)
    {
        insert(head, x);
    }

    void print()
    {
        node* cur = head->next;
        while (cur != head)
        {
            std::cout << cur->data.c_str();
            cur = cur->next;
        }
        std::cout << std::endl;
    }

private:
    node* head;
};

int main()
{
    list<cmj::string> lt;
    lt.pushback("0000");
    lt.pushfront("11111");
    lt.print();
    return 0;
}
